Using a runtime engine to facilitate dynamic adaptation of deep neural networks for efficient processing

ABSTRACT

The disclosed embodiments relate to a system that facilitates dynamic runtime execution of a deep neural network (DNN). During operation, the system receives a model, a set of weights and runtime metadata for the DNN. The system also obtains code to perform inference-processing operations for the DNN. Next, the system compiles code to implement a runtime engine that facilitates throttling operations during execution of the inference-processing operations, wherein the runtime engine conserves computing resources by selecting portions of the inference-processing operations to execute based on the runtime metadata.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims priority under 35 U.S.C. § 119(e) to U.S. Provisional Application Ser. No. 62/900,311, entitled “Dynamic Adaptation of Deep Neural Networks for Efficient Processing,” by inventors Sek Meng Chai and Jagadeesh Kandasamy, filed on 13 Sep. 2019, which is hereby incorporated by reference. This application also claims priority under 35 U.S.C. § 119(e) to U.S. Provisional application Ser. No. 63/018,236, entitled “Dynamic Adaptation of Deep Neural Networks for Efficient Processing,” by inventors Sek Meng Chai and Jagadeesh Kandasamy, filed on 30 Apr. 2020, which is hereby incorporated by reference. This application is also related to pending U.S. patent application Ser. No. 16/______, entitled “Optimizing Execution of a Neural Network based on Operational Performance Parameters,” by inventors Sek Meng Chai and Jagadeesh Kandasamy, filed on the same day as the instant application (Attorney Docket No. LATI20-1003), which is hereby incorporated by reference.

BACKGROUND Field

The disclosed embodiments generally relate to techniques for improving the performance of artificial neural networks. More specifically, the disclosed embodiments relate to a platform that facilitates dynamic adaptation of deep neural networks to optimize execution on resource-constrained computing devices.

Related Art

Deep neural networks, which are built from dozens or hundreds of layers of artificial neurons, have proven to be quite effective at various pattern-recognition tasks, such as computer vision, speech recognition and natural language processing. These deep neural networks typically operate by using multiple layers of neurons to progressively extract higher-level features from raw input. For example, in an image-processing application, lower layers of the neural network may identify edges, higher layers may identify arrangements of edges, and even higher layers may use semantic context in order to identify specific objects.

Deep neural networks tend to be computationally intensive because computational operations need to be performed to generate successive outputs for a large number of layers. This is not a significant problem if the deep neural network computations are performed on an enterprise computing system, which provides large numbers of computing cores and commensurately large amounts of memory and power budget. However, it is more of a problem to use such deep neural networks in resource-constrained environments, such as in edge devices, autonomous vehicles or portable devices, which only provide limited amounts of processing power, memory capacity and battery life.

Hence, what is needed is a technique for adapting deep neural networks for efficient execution on resource-constrained computing environments.

SUMMARY

The disclosed embodiments relate to a system that facilitates dynamic runtime execution of a deep neural network (DNN). During operation, the system receives a model, a set of weights and runtime metadata for the DNN. The system also obtains code to perform inference-processing operations for the DNN. Next, the system compiles code to implement a runtime engine that facilitates throttling operations during execution of the inference-processing operations, wherein the runtime engine conserves computing resources by selecting portions of the inference-processing operations to execute based on the runtime metadata.

In some embodiments, during the throttling operations, the runtime engine identifies portions of the DNN to mask out and/or selects portions of the DNN to traverse based on a graph analysis involving the model, the set of weights and the runtime metadata.

In some embodiments, the graph analysis involves scheduling data-fetching operations based on the runtime metadata to facilitate execution of the DNN.

In some embodiments, the runtime metadata comprises information about statistically relevant execution paths through the DNN, which are determined based on activations in the DNN and associated sub-tensors.

In some embodiments, the runtime metadata specifies runtime masks to facilitate selectively executing inference-processing operations for the DNN.

In some embodiments, the runtime metadata specifies different masks for different DNN outputs.

In some embodiments, the runtime engine is configured to cryptographically decode a watermark pattern encoded in the set of weights to facilitate validating the DNN.

In some embodiments, the runtime engine is configured to determine a current runtime state and a target runtime state for the DNN, wherein the throttling operations select an operational plan to achieve the target runtime state from the current runtime state.

In some embodiments, the current runtime state comprises a current execution context and a current input context, wherein the current execution context comprises current activations and/or outputs for the DNN, and the current input context comprises contextual features associated with current inputs to the DNN.

In some embodiments, the runtime engine is configured to decode the set of weights during the inference-processing operations based on dictionary index values in the runtime metadata.

The disclosed embodiments relate to a system that optimizes execution of a DNN based on operational performance parameters. During operation, the system collects the operational performance parameters from the DNN during operation of the DNN, wherein the operational performance parameters include parameters associated with operating conditions for the DNN, parameters associated with resource utilization during operation of the DNN, and parameters associated with accuracy of results produced by the DNN. Next, the system uses the operational performance parameters to update the DNN model to improve performance and efficiency during execution of the DNN.

In some embodiments, the system also deploys and executes an updated DNN model at a location in a hierarchy of computing nodes, wherein the location is determined based on a global system-level optimization.

In some embodiments, higher-level nodes in the hierarchy of computing nodes provide relatively more computing power, lower-level nodes in the hierarchy provide relatively less computing power, and each DNN model is optimized for a specific level of the hierarchy in which the DNN model is deployed.

In some embodiments, the operational performance parameters include information that is used to optimize overall network bandwidth within the hierarchy of computing nodes in which the DNN operates.

In some embodiments, the updated DNN model is deployed while the DNN continues to operate.

In some embodiments, the operational performance parameters include profiling data, which identifies pathways within the DNN that are activated while the DNN performs inference-processing operations.

In some embodiments, the profiling data is used to synthesize additional training data, which is used to train the updated DNN model to improve robustness.

In some embodiments, while the DNN executes, a runtime engine for the DNN selectively activates pathways in the DNN to facilitate computationally efficient inference-processing operations.

In some embodiments, the operational performance parameters are analyzed to determine coefficients for regularizer terms in a loss function that is used to train the updated DNN model, wherein the regularizer terms include a quantization term, which represents differences between pre-quantization and post-quantization weight values in the DNN, and a magnitude term, which represents magnitudes of the weight values.

In some embodiments, a runtime engine for the DNN uses a policy generated using the operational performance parameters to achieve two or more of the following objectives: maximizing classification accuracy of the DNN; minimizing computational operations performed while executing the DNN; minimizing power consumption of a device, which is executing the DNN; and minimizing latency involved in executing the DNN to produce an output.

In some embodiments, the updated DNN model is comprised of a plurality of DNN models trained simultaneously based on the operational performance parameters.

The disclosed embodiments relate to a system that generates runtime metadata, which includes runtime execution parameters for a DNN. During operation, the system performs post-training operations on the DNN to identify effective execution paths through the DNN to produce desired computational results. While performing these post-training operations, the system first evaluates an inference of the DNN across a test data set and stores associated DNN activations. Next, the system selects statistically relevant execution paths through the DNN based on the DNN activations. Finally, the system generates the runtime metadata based on the selected execution paths through the DNN, wherein the DNN metadata identifies portions of the DNN to be selectively executed at runtime.

In some embodiments, the runtime metadata specifies runtime masks to facilitate selectively processing DNN nodes. In one embodiment, only a subset DNN nodes are selected for processing, and a subset of DNN nodes that are masked are not selected for processing.

In some embodiments, the runtime metadata specifies different masks for different object classes. The subset of DNN nodes selected for processing is based on the statistical activation of the nodes that is used to select the object classes. The object classes can be prioritized such that the processing based on the masks determines order of processing of the DNN nodes.

In some embodiments, the selective execution of the DNN nodes facilitates conserving computing resources. Note that a set of object classes may be deprioritized, such that the associated DNN nodes do not need to be computed, or certain DNN nodes are deemed to have low priority in resolving object classification.

The disclosed embodiments relate to a system that generates DNN training metadata to facilitate training a DNN. During operation, the system receives a DNN model and associated parameters at a DNN training interval. Next, the system generates compiler intermediate representations based on the DNN model and associated parameters and available computing resources. The system then generates the DNN training metadata based on the compiler intermediate representations, wherein the DNN training metadata comprises information, including one or more of computing resource utilization, memory bandwidth availability, and power consumption. Finally, the system uses the DNN training metadata during a subsequent training operation for the DNN.

In some embodiments, generating the DNN training metadata involves performing a compiler graph analysis and generating training feedback based on the analysis.

In some embodiments, the computing resource utilization in the dynamic DNN metadata affects architecture selection and weight selection during the subsequent training operation for the DNN.

The disclosed embodiments relate to a system that executes a DNN based on a current operational context. During operation, the system receives a current runtime state for the DNN, comprising a current DNN execution context and a current DNN input context, wherein the current DNN execution context comprises current DNN activations and/or DNN outputs, and wherein the current DNN input context comprises contextual features associated with current inputs to the DNN. Next, the system uses the current runtime state to determine a target runtime state for the DNN. The system then generates an operational plan to achieve the target runtime state from the current runtime state. Finally, the system controls the DNN to execute the operational plan.

In some embodiments, while using the current runtime state to determine the target runtime state, the system uses a planning agent algorithm to determine the target runtime state, wherein the planning agent was previously trained using a reinforcement learning technique. The planning agent learns a policy to transition from the current runtime state to the target runtime state. In one embodiment, the planning agent may use a policy that is based on input data. In another embodiment, the planning agent is trained using an unsupervised methodology with rewards for conserving computing resources for the DNN.

In some embodiments, controlling the DNN to execute the operational plan involves performing one or more of the following throttling operations: skipping frames in the input; and selectively masking out portions of the DNN. In one embodiment, the input nodes of the DNN are masked to reduce the rate of input data. In another embodiment, the output nodes are masked to reduce the rate of output data. In the embodiments in which the input and output data are masked, the DNN may infer there is no change in the input data or output result, or the DNN may interpolate the input data or output results based on previous values of the input data or output results.

The disclosed embodiments relate to a system that watermarks a DNN. During operation, the system receives a watermark pattern. Next, during a training operation for the DNN, the system constrains certain DNN parameters based on values in the watermark pattern, so that after the training completes, the watermark pattern is encoded in the certain DNN parameters of the trained DNN.

In some embodiments, the DNN parameters comprise input weights for neurons in the DNN.

In some embodiments, after the training operation, the system additionally generates a checksum for the DNN parameters.

The disclosed embodiments relate to a system that compresses a DNN. During operation, the system receives a trained DNN, which includes DNN parameter values. Next, the system generates a dictionary for the DNN parameter values. Finally, the system encodes the DNN parameter values using corresponding dictionary index values.

In some embodiments, the system receives a set of dictionary values for compression. During training, the system constrains certain DNN parameters based on values in the dictionary, so that after the training completes, the DNN parameters contains only those values in the dictionary.

In some embodiments, the system decodes the encoded DNN parameter values during runtime for the DNN. In one embodiment, the system decodes the encoded DNN to extract the watermark pattern encoded in the DNN parameters. In another embodiment, the system decodes the encoded DNN to un-compress the parameter values based on the dictionary.

The disclosed embodiments relate to a system that facilitates visualization of DNN training results across different bit precisions. During operation, the system trains and tests the accuracy of a DNN using different bit precisions for DNN weights. Next, the system displays a histogram of the DNN weights and associated accuracy results for each of the different bit precisions to facilitate visualizing how bit precision affects discrimination capabilities of the DNN. The system displays the changes in accuracy for certain object classes based on bit-precision reduction for each DNN layer. The system displays the weight distributions of the DNN parameters for each DNN layer.

The disclosed embodiments relate to a system that processes neural network inferences in a DNN using bit planes. During operation, the system separates a tensor associated with the DNN into bit planes. Next, the system resolves the bit planes, wherein matrix multiplication and summation operations in the convolution are resolved through approximation using a bit-counting process, and wherein pooling and non-linear activation operations are resolved by using each of the bit planes as a new input vector.

In some embodiments, only a single bit plane, which is associated with a most-significant bit (MSB), is resolved.

In some embodiments, the system additionally fuses the bit planes by shifting the bit planes based on MSB values.

The disclosed embodiments relate to a system that quantizes a DNN based on tensor splitting to reduce information loss. During operation, the system receives a tensor, which is associated with a layer of the DNN, wherein a distribution of values in the tensor includes a peak. Next, the system splits the tensor into sub-tensors, wherein a first sub-tensor includes values in proximity to the peak and a second sub-tensor includes values that are not in proximity to the peak. Finally, the system separately quantizes the first and second sub-tensors using different quantization parameters to improve accuracy and reduce information loss.

In some embodiments, a bin size associated with the quantization of the first sub-tensor quantization has a finer granularity than a bin size associated with the quantization of the second sub-tensor.

In some embodiments, while subsequently executing the DNN, the first sub-tensor and the second sub-tensor can be selectively computed to dynamically adjust the number of computational operations involved in executing the DNN.

In some embodiments, the tensor is split into more than two sub-tensors based on multiple peaks in the distribution, wherein each of the sub-tensors is separately quantized using different quantization parameters. The disclosed embodiments relate to a system that trains a controller to manage runtime execution of a throttleable neural network (TNN). During operation, the system receives a training data set comprising training examples, wherein each training example comprises an input to the TNN and corresponding activation paths through the TNN, which were generated in response to the input. Next, the system generates a policy to activate the TNN based on analysis of the inputs to the TNN and the corresponding activation paths.

In some embodiments, inputs to the TNN comprise high-resolution images, and associated inputs in the training data for the controller comprise down-sampled versions of the high-resolution images.

In some embodiments, each training example in the training data set for the controller includes an output of the TNN, which was generated in response to a corresponding input.

In some embodiments, the reward function balances two or more of the following objectives: maximizing classification accuracy of the TNN; minimizing computational operations performed while executing the TNN; minimizing power consumption of a device, which is executing the TNN; and minimizing latency involved in executing the TNN to produce an output.

In some embodiments, the controller is compiled and incorporated into a runtime engine for the TNN.

In some embodiments, the policy is generated using a reinforcement learning technique to train the controller based on the training data set and a reward function to selectively activate throttleable modules in the TNN to facilitate execution of the activation paths.

In some embodiments, the throttleable modules include the first sub-tensor and the second sub-tensor in the TNN.

BRIEF DESCRIPTION OF THE FIGURES

FIG. 1 illustrates a dynamic adaptation framework to facilitate the operation of deep neural networks on resource-constrained computing devices in accordance with the disclosed embodiments.

FIG. 2 illustrates the internal structure of several modules from FIG. 1A in accordance with the disclosed embodiments.

FIG. 3A presents a flow chart illustrating operations performed while facilitating dynamic runtime execution of a DNN in accordance with the disclosed embodiments.

FIG. 3B presents a flow chart illustrating operations performed while optimizing execution of a DNN based on operational performance parameters in accordance with the disclosed embodiments.

FIG. 4 presents a flow chart illustrating operations performed while generating runtime metadata for a DNN in accordance with the disclosed embodiments.

FIG. 5 presents a flow chart illustrating operations performed while generating DNN runtime metadata to facilitate training a DNN in accordance with the disclosed embodiments.

FIG. 6 presents a flow chart illustrating operations performed while executing a DNN based on a current operational context in accordance with the disclosed embodiments.

FIG. 7 presents a flow chart illustrating operations performed while watermarking a DNN in accordance with the disclosed embodiments.

FIG. 8 presents a flow chart illustrating operations performed while compressing a DNN in accordance with the disclosed embodiments.

FIG. 9 presents a flow chart illustrating operations performed while generating a visualization of DNN training results across different bit precisions in accordance with the disclosed embodiments.

FIG. 10 presents a flow chart illustrating operations performed while processing neural network inferences in a DNN using bit planes in accordance with the disclosed embodiments.

FIG. 11 presents a flow chart illustrating operations performed while quantizing a DNN based on tensor splitting to reduce information loss in accordance with the disclosed embodiments.

FIG. 12 presents a flow chart illustrating operations performed while training a controller to manage runtime execution of a TNN.

FIG. 13 illustrates a magnified version of a display output in accordance with the disclosed embodiments.

FIG. 14 illustrates an exemplary compression report in accordance with the disclosed embodiments.

FIG. 15 presents a diagram showing a detailed compression report for one tensor in accordance with the disclosed embodiments.

FIG. 16 illustrates an edge continuum in accordance with the disclosed embodiments.

FIG. 17 illustrates a hierarchy of computing nodes in accordance with the disclosed embodiments.

FIG. 18 illustrates different types of communications among computing nodes in a hierarchy of computing nodes in accordance with the disclosed embodiments.

DETAILED DESCRIPTION

The following description is presented to enable any person skilled in the art to make and use the present embodiments, and is provided in the context of a particular application and its requirements. Various modifications to the disclosed embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other embodiments and applications without departing from the spirit and scope of the present embodiments. Thus, the present embodiments are not limited to the embodiments shown, but are to be accorded the widest scope consistent with the principles and features disclosed herein.

The data structures and code described in this detailed description are typically stored on a computer-readable storage medium, which may be any device or medium that can store code and/or data for use by a computer system. The computer-readable storage medium includes, but is not limited to, volatile memory, non-volatile memory, magnetic and optical storage devices such as disk drives, magnetic tape, CDs (compact discs), DVDs (digital versatile discs or digital video discs), or other media capable of storing computer-readable media now known or later developed.

The methods and processes described in the detailed description section can be embodied as code and/or data, which can be stored in a computer-readable storage medium as described above. When a computer system reads and executes the code and/or data stored on the computer-readable storage medium, the computer system performs the methods and processes embodied as data structures and code and stored within the computer-readable storage medium. Furthermore, the methods and processes described below can be included in hardware modules. For example, the hardware modules can include, but are not limited to, application-specific integrated circuit (ASIC) chips, field-programmable gate arrays (FPGAs), and other programmable-logic devices now known or later developed. When the hardware modules are activated, the hardware modules perform the methods and processes included within the hardware modules.

Dynamic Adaptation Framework Features

The dynamic adaptation framework for DNNs that is described in this specification includes a number of novel features, which are described below.

Dynamic Runtime Execution System

In DNNs, there is a need for runtime software to control throttling by running selected portions of a trained DNN. This runtime software can be automatically generated so the developer only needs to focus on application development rather than dynamic runtime settings for a DNN. This code-generation process can be accomplished using a compiler with insights obtained from executing a trained DNN. During operation, the system uses a runtime engine, which includes compiler-generated conditional code that selects paths to execute by selective masking. This technique also makes use of metadata information, which helps the runtime engine select and map compute resources based on current processor workload.

During execution, a throttling process selects which pathways should be traversed to accomplish a specific DNN task. By selecting and executing an appropriate subset of paths, the system approximates optimal DNN results. This technique is much akin to DNN quantization and pruning, but instead of removing the bits and edges from the DNN, we are masking the DNN so that the runtime engine can selectively execute portions of the DNN. Associated compression and encoding operations can be used to determine how many bits should be used for specific tasks.

Technique for Generating DNN Runtime Metadata

To facilitate efficient execution of the runtime engine, we need to automatically generate the runtime metadata without having to retrain the network. In one embodiment, this can be accomplished through post-training analysis of a pre-trained DNN to find the most effective paths through the DNN to produce desired results. For example, if certain object classes have very distinct features as compared with other classes of objects, they are likely to have orthogonal activations in the DNN, which allows for selective masking of the network without sacrificing overall accuracy. For example, cat/dog object classes may have separate and distinct visual features as compared with automotive vehicles. As such, separate masks can be generated to selectively execute cat/dog pathways to conserve on computing resources. We are essentially dynamically pruning the DNN by selectively processing the DNN nodes. This reduces power consumption and also improves processing latency.

In one embodiment, the effective paths in DNN can be trained to enforce the separation of filters for specific classes of objects during training. Selected DNN parameter weights are updated using clustering or dropout training procedures to utilized only portions of the network, and therefore, effective ensemble network paths are formed during training. For example, cat/dog object classes are trained as a dataset cluster to form a DNN ensemble, while automotive vehicle classes are trained as a separate dataset cluster to form a separate but connected DNN ensemble during training. The runtime metadata can be generated based on effective paths during DNN training. In an example embodiment, a hyperparameter for DNN training is used to determine the maximum number of dataset clusters and ensembles that affects the number of effective paths in the runtime metadata.

Current approaches involve pruning the DNN by removing DNN nodes and edges that are not statistically relevant. In our approach, rather than removing portions of the network, we selectively mask out the same portions of the network under control of the runtime system. During pruning, you are effectively short-circuiting a node or ensemble if the node or ensemble is removed. In contrast, when using runtime masks, the runtime engine selectively executes the node after DNN training, which is equivalent to the short-circuiting, but without removal of DNN nodes and edges that may be needed for operation in a different operational condition. Our approach maintains the learning capacity of the DNN while providing as efficient an computational workload as pruning.

Technique for Generating DNN Training Metadata

This technique facilitates communication between the AI training system and the compiler. Current approaches consider the training and compilation workflows to be separate. As such, the current approaches perform separate and disjoint optimizations during the AI training and compilation processes. These separate workflows can result in long development times, and typically produce results that are non-convergent or non-optimal, from an end-to-end workflow perspective. In contrast, integrating AI training and compilation into a single automated workflow facilitates joint optimization of AI training and compiler analysis operations.

AI training involves searching for DNN parameters that offer the best accuracy for a specific task. Given compiler information about which processing operations are more desirable (e.g., with respect to latency, power, and resource utilization), the AI training process can be optimized so that the DNN processing operations perform the more-desirable operations. During this compilation process, the compiler manages the hardware resources in which the inference processing occurs, and it can provide resource-utilization information to the AI training system to influence neural network architecture selection and/or weight selection accordingly.

This technique operates by first performing compiler graph analysis, and then generating feedback for the AI training system based on the analysis operations. The compiler uses a graph to store operational information (e.g. register allocation, computational dependencies, processing latency), and the associated analyses consist of best traversal path through the graph. The aggregated information from graph analyses (e.g. overall processing rate, power, resource utilization) can be provided to AI training for each DNN training iteration or epoch. The AI training may include a loss function that penalizes an increasing resource utilization feedback from the compiler. Current approaches may include a heuristic modeling to represent overall resource utilization during initialization of the AI training procedure. In contrast, our approach includes direct feedback during AI training procedure for a more optimal selection of DNN parameters and compiler output.

Moreover, compiler optimizations typically aim to provide certain execution guarantees, and the AI training generates results (e.g., selected bit precisions) that can help compiler optimizations improve these execution guarantees. For example, in one embodiment, the compiler provides feedback that a floating point operation is needed (e.g. floating point hardware and associated processing latency). After each training epoch, the DNN parameters values are calculated, and the compiler optimization generates DNN training metadata containing a list of overall resources needed for the set of calculated DNN parameter values. Based on the DNN training metadata, the AI training decides to quantize the parameter to an 8-bit integer value, which then frees up the floating-point resources in lieu of integer processing resources for the compiler to manage.

Technique for Executing a DNN Based on a Current Operational Context

The runtime engine determines a current operational context and then selects target runtime settings based on the current operational context. It is possible to obtain current runtime information from the computing system, such as processor utilization and memory bandwidth. However, this computing system information does not contain specific DNN runtime information that pertains to a current input. (For example, video images in a video input may be dark, which may cause inference performance to be low.) By obtaining specific internal details about how the DNN inference is operating, it is possible to throttle the DNN into a different operational state to achieve better algorithmic performance on a resource-constrained computing system. The DNN runtime operation is dependent on the input and the model (selected DNN architecture and trained weights). In one embodiment, our technique operates by extracting contextual features from both the input and the model's operational performance, and then based on these contextual features, generates an operational plan for a subsequent operational state. In another embodiment, our technique generates an operational plan based on available resource (e.g. power, compute resource, memory) to processing the DNN model.

The contextual features of the input can be analyzed by performing a coarse analysis on the input data. In an exemplary use case, the DNN's task is to detect objects in an image. For this use case, we can provide an additional DNN that is very small to work on a low-resolution (sub-sampled) image input. This small DNN can then provide contextual information, such as scene context (sky, ground, water, day/night, etc.) and event changes (e.g., motion change), which can be used to better control throttling operations for the DNN.

The DNN context can be extracted based on DNN activations or the DNN output, wherein this DNN context can be used to determine how the DNN is operating based on current DNN inputs. The DNN and input contexts can then be combined to form a current runtime state, which is sent to a planning agent to determine the most-efficient target runtime state.

In one embodiment, this contextual information is used to throttle at least three elements of the processing pipeline: (1) data frames, (2) data segmentation, and (3) semantic reasoning. In data frames, the system decides how many frames can be throttled down in a window of N frames. For example, in an object-tracking use case, suppose we detect the object in the first and last frames. If we can interpolate the motion between the first and last frames, we do not need to perform object-recognition computations for all N of the frames. The contextual information can also be related to the confidence of the object classification in the first frame. A higher confidence in the object classification may make it possible to skip more frames to reduce computing workload.

In data segmentation, the controller uses the DNN context to decide if all or part of the DNN needs to be processed. For high-confidence detection, it may be sufficient to process only a global context of the DNN (e.g., where only sub-sampled imagery is processed).

In semantic reasoning, the controller is coupled with a time-series network (e.g., LSTM, long short term memory) where object detections are resolved over the N frames. If frames are skipped, the LSTM (with its generative properties) can resolve state changes over the N frames. That is, if the system observes the first and last frames of an N frame window, the LSTM can predict the other states in the N frame window. However, for higher accuracy in prediction, intermediary frames may be needed (e.g., frames at quarter points N/4, N/2 and 3N/4).

Moreover, by capturing DNN contextual information, in some cases it may be possible to perform the DNN operations in a predetermined manner (i.e., for the next N frames). As such, the DNN can operate in a more deterministic manner, which facilitates prefetching and other mechanisms that could not be performed for a less deterministic computation.

In one embodiment, the runtime engines collect operational performance parameters, which are used by a deployment packager to update the DNN by training and optimizing the DNN model. This update is performed to improve the overall DNN performance and efficiency. During operation, a deployment packager decides to initiate this update based on a global system-level optimization over a hierarchy of computing nodes as is illustrated in FIG. 16. Referring to FIG. 16, a set of software tools 1602 generates a specially optimized DNN and an associated runtime engine for each target computing platform 1611-1615. These target platforms 1611-1615 form an edge continuum, wherein each target platform includes different resources and has different capabilities. Note that the deployment packager is responsible for determining whether a DNN will execute on a 4-bit platform 1614, a 16-bit platform 1612 or a 32-bit platform 1611.

During operation, DNN models can be transmitted to different target platforms to update a currently executing DNN, wherein these transmissions can be performed simultaneously. Note that pushing a DNN model to an edge device can significantly reduce the network bandwidth, which was previously required to execute a DNN model in the cloud. This is because the network bandwidth required to transmit a DNN model to an edge device is orders of magnitude lower than the network bandwidth required to transmit IOT data to the cloud. Moreover, during execution, each DNN collects inference results and operational parameters and communicates them back to software tools 1602 to help in updating the DNN model. The DNN and associated runtime engine remains operational on the hierarchy of computing nodes while the updated DNN is being optimized and deployed.

FIG. 17 illustrates an exemplary hierarchy of computing nodes in accordance with the disclosed embodiments. This hierarchy includes a number of basic runtime engines (REs) 1701-1708, which can be located in edge devices, such as motion sensors, cameras or microphones. These basic REs 1701-1708 assume the existence of an associated intermediate or high-end device capable of delivering DNN models to basic REs 1701-1708 and collecting log information from basic REs 1701-1708. The hierarchy also includes a number of hub REs 1711-1713, which can be located in a network hub, and which include a modest hardware device, such as a Raspberry Pi™ that is capable of hosting an operating system such as Linux. Note that each hub RE 1711-1713 is capable of supporting a number of basic REs, which involves collecting their log data and, based on this information, triggering the uploading of new DNN models to them. Finally, the hierarchy includes a server RE 1721, which operates on server-class hardware and collects information from a number of hub REs 1711-1713. Server RE 1721 uses this collected information to retrain models on hub REs 1711-1713 if needed, and to manage the distribution of updated DNN models to hub REs 1711-1713.

The hierarchy of computing nodes illustrated in FIG. 17 can be used to implement a hierarchy of filters. For example, suppose we have a camera sensor. We first perform a filtering operation at an edge device (possibly located in the camera) to determine whether a human is present. If a human is present, we send the image to a higher-level filter in a more powerful computing device to determine whether the human is holding something. If the human is holding something, we send the image to an even more powerful computing device to determine what the human is holding. Is it an umbrella, a gun or a baseball bat? In this multi-layer approach, each successive filter requires more processing power, and the runtime engine needs to match each DNN model that implements a filter to an appropriate target hardware platform.

In another example, a home IOT system may include a doorbell camera and a driveway camera, wherein each camera is configured to look for different things. For example, the backyard camera may be looking for deer and the driveway camera may be looking for a car. In this example, a higher-power computing platform, such as a gateway, can be used to determine whether a deer, which was detected by the backyard camera, is coming or going.

FIG. 18 illustrates different types of communications among computing nodes in the hierarchy of computing nodes in accordance with the disclosed embodiments. More specifically, FIG. 18 illustrates how various items, such as reports, schedules and models can be communicated between a hub RE 1811 and basic REs 1801-1803. During operation, hub RE 1811 may request various data items from basic REs 1801-1803, such as inferences, accuracy parameters, and system loads. These requests are sent to a reporting unit within each basic RE 1801-1803, which continuously collects system data. In response to a request, a basic RE 1801-1803 can return a report, which comprises a collection of these operational performance parameters.

Hub RE 1811 can also send an inferential model to basic REs 1801-1803. For example, the inferential model can be a DNN, which includes a graph, associated parameters and an executable binary. Hub RE 1811 can additionally send a schedule for the execution of models to basic REs 1801-1803. This schedule describes a sequence of execution of the models in the basic RE's memory. If the basic RE has several models in its memory but no schedule, then those models can be executed in round robin order. A schedule can specify a policy, which determines when a model should be run, and how often it should be run. For example, a policy can specify that a person-detecting model should be run once per hour, and another policy can specify that one model should be run in the summertime and another model should be run in the wintertime.

The above-described system operates in a hierarchy of computing nodes and can be tailored for various application requirements. For example, if a specific application requires a large volume of data and the computing system does not provide enough bandwidth to send this large volume of data to the cloud, the system can send models to edge devices (basic REs) to filter the data, or to actually perform the inference-processing operations on the data. In another application, the objects that are being monitored can periodically change locations. In this case, the system tracks the locations of the objects and deploys models, which are specifically tailored for the objects, to edge devices that are located in proximity to the objects.

The deployment packager collects and generates operational performance parameters that can be used to optimize and train the DNN models by optimizing a loss function, such as the function listed below

L(W)+λ₂Σ_(i=1) ^(N) ∥W ^((i)) −{tilde over (W)} ^((i))∥₂ ²+λ₃Σ_(i=1) ^(N) ∥W ^((i))∥₂ ²  (Eq.1)

The first term L(W) is the main loss function, which is a typical loss function for DNN training. Note that the DNN training objective is to minimize this loss function, which improves DNN accuracy. The second and third terms are regularizer terms, which are used to guide the DNN training by providing mathematical constraints to the DNN parameter values W^((i)). In this case, the regularizer terms are used for quantization, for example to train the DNN to use 8-bit precision or lower instead of FP32 bit precision. The second term deals with keeping W^((i)) and ˜W^((i)) close together (e.g., FP32 and INT8 values should be close together so as to reduce the loss due to differences in bit-precisions). The third term deals with keeping W^((i)) values small and close to zero. The lambda values (λ₂ and λ₃) are hyperparameters for DNN training, which set the weighting for the second and third terms.

If the operational parameters indicate poor operational performance, this means the presently deployed model is not working well. Operational performance parameters can be used to improve DNN model performance and efficiency. In this case, we can reduce the lambda values k₂ and k₃ so that they have less effect on the accuracy. This effectively relaxes the training function so that performance can increase.

Technique for Watermarking a DNN

Once a DNN is trained and deployed, a developer or user may want to identify the DNN to ascertain its origins. For example, in an AI marketplace, you may want to only use a DNN from a reputable source, or use DNNs that are generated and quantized by a reputable tool maker. Furthermore, one might want to know that the models are not tampered with (e.g., to prevent attacks where bits in the DNN parameters are manipulated).

Our watermarking technique operates by encoding information in parameters of a DNN to facilitate verifying its authenticity and securing its validity. This technique generally operates by encoding a watermark pattern in DNN weights by constraining the possible values for weights during training. In one embodiment, the constraining the possible values can be achieved by optimizing a loss function as described in Eq.1, where regularizer terms guide DNN parameter value during training based on the watermark pattern. The training operation can also use parameter values of a pre-trained DNN. At runtime, an associated decoder in the runtime engine can dynamically verify the authenticity of the DNN by verifying the watermark, which involves decoding the DNN watermark based on the quantized values of the DNN parameters.

This watermarking technique supports brand sustainment and security of the DNN models. Moreover, it allows the DNN model to be time stamped and labeled based on the tool flow. Current approaches encrypt the DNN model and associated metadata files (e.g. timestamp and tool flow information). In contrast, our approach directly embedded the watermark, timestamp, and metadata information into the DNN parameter values, and thus reduces the attack surface for tampering. The DNN model is still operable with the embedded watermark because it is quantized accordingly during AI training.

Technique for Compressing a DNN

This technique compresses the weights of a DNN based on a dictionary, which includes entries that contain values for specific weights, wherein the entries can be referenced through a shorter index, which is used to encode the specific weights. Also note that the encoding of the weights can be changed during the AI training process to reduce the size of the dictionary.

Note that if only power-of-two values (2, 4, 8, 16, . . . ) are used to represent DNN weights, there exists only a small set of possible values for the weights. A simple compression routine (e.g. ZIP or 7zip) can be used to analyze the possible values and compress all of the weights, but this is neither guaranteed nor necessarily optimal. Our technique operates by preselecting a symbol table, which defines the available values for weights (e.g. power-of-two) that can be used during DNN training. This dictionary (or lookup table) includes entries for the available values that are mapped to specific symbols. Each symbol is basically a compressed encoding (or dictionary index) that represents the available values. For example, if the only power-of-two values are 2, 4, 8, and 16, we only need to use a two-bit symbol to encode these four possible power-of-two values. During runtime inferencing, the dictionary can be used to look up the encoded power-of-two values based on their associated two-bit symbols. Note that we can also tie the encoding to a training process so that efficiency in encoding and decoding guides the target AI training and quantization operations.

Hence, this specialized encoding technique can greatly improve compression of DNN parameter files. In one embodiment, a decoding procedure during runtime inferencing can be performed by available processor hardware. In another embodiment, a software decoding procedure is generated by a compiler, wherein the software operates a lookup table with a hash table of the available values. In yet another embodiment, the compiler generates software specifically based available values (e.g. power-of-two values for multiplication in DNN processing can be represented as bit-shifting operation, wherein the amount of shifts are based on DNN parameters trained to use only power-of-two values).

Visualizing DNN Training Results Across Different Bit Precisions

Our DNN training system trains the DNN using quantized bit-precision, and also with special encodings such as power-of-two values. In such systems, there is a need to visualize how bit precision affects the distribution of weights in the DNN layers. Because we test DNN accuracy during the quantization process, we have results based on changing bit precision for different DNN models/layers. We can use these results to produce a visualization of the accuracy versus bit precision, which can help to determine how bits are used to represent the range and sparsity of values. Such a visualization can be useful in explaining the operation of the DNN model, as well as highlighting filters and layers in the DNN that are more prone to quantization.

For example, a visualization of the confusion matrices and their relationships with changing bit precision can highlight the sensitivity of the object classes. This can help developers improve DNN performance by grouping similar objects and creating hierarchy in the classification layers. This visualization facilitates user interaction with the underlying tools, whereby the user can provide input regarding a target bit precision. For example, by grouping two object classes such as dogs and cats as a new object class called “small pets”, the AI training can achieve higher quantization levels because the DNN model does not need to use more bits to separate the dogs and cats as separate objects.

Our visualization technique operates by first training and testing the accuracy of a DNN using different bit precisions for DNN weights. Next, the technique displays a histogram of the DNN weights and associated accuracies for each of the different bit precisions. This facilitates visualizing how bit precision affects discrimination capabilities of the DNN. For example, see FIGS. 13-15, which are described in further detail below.

Processing Inferences in a DNN Using Bit Planes

DNNs operate by performing convolutions (matrix multiply, summation), followed by pooling and non-linear activations. Most approaches to making such inference-processing operations efficient deal with reducing bit-width (e.g., from floating point to 8-bit or lower-bit precision). It may also be possible to use approximations with respect to the computation (i.e., dealing with the pooling and non-linear activations using operations such as tan h and RELU).

We have previously shown that a DNN can be trained to have weights that only have power-of-two values. The most straightforward computational mapping may be to use bit-shifts rather than integer multipliers. However, we can further approximate the computations via bit plane manipulations.

DNN tensors are typically defined with respect to NWHC (batch size N, width W, height H, and channel C), wherein “batch size” refers to the number of image frames; “width” and “height” refer to the x and y dimensions of the image frame, respectively; and “channel” refers, for example, to the color channels R, G, and B.

We can separate the DNN tensor further into bit planes, including MSB and LSB planes. Computations for the DNN tensor can be represented with a control graph, governed by the bit planes. Approximations can be performed by selecting particular computations, as described in the control graph, wherein selection is based dictated by the values in the MSB and LSB planes.

When the weights are power-of-two values and we only need a few bits to represent the weights, then it might make sense to resolve the computation by looking at individual bits. For example, if the weight values use only three bits, we have three bit planes, which can be resolved using three separate binary tensor operations. The bit planes do not have to consecutive, with respect to their associated value encodings (e.g. we can use bit planes 1, 3, and 5 of the DNN tensor). Hence, you can resolve the first MSB bit plane first, then the second MSB bit plane, and then the third (i.e., LSB) bit plane. For each bit plane, because we are doing only binary calculations, we can resolve the matrix multiplication and summation operations using a bit-counting process. Therefore, convolutions in a bit plane can be reduced to bit-counting. (Note that we are essentially “unrolling” the multiply/add operations.) We can resolve the pooling and non-linear activations by using the three bit-planes as the new input vectors. Moreover, the bit planes can be fused by bit-shifting the bit planes based on the MSB values. Alternatively, the second and third bit-planes can be ignored (approximated away) and only the MSB bit plane can be analyzed.

In this example embodiment, we approximate the multiply/add operations in DNN tensors using binary tensor operations, operable in bit-planes. Hence, we can reduce multiply/add operations to bit-counting using power-of-two values, with only a few total bits selecting the computations defined in the control graph.

Explainability

During runtime operation of the neural network, our framework can perform a profiling operation to keep track of all pathways the neural network activates while making an inference, such as classifying a car. This information can be used to gain insight into how the neural network makes a specific inference. For example, say we have a neural network that recognizes objects in an image, such as a car, a dog or a bicycle. During the profiling process, the system can keep track of how many different pathways in the neural network are activated while recognizing a car. Hence, the above-described profiling process essentially produces an activation heat map, which indicates that a specific pathway is being hit a lot. The pathways represent the visual features that are representative of the object.

If an erroneous inference is detected (e.g. via user input or other DNN inferences), then the erroneous pathway indicates the visual features that produces the erroneous inference results. A comparison of the erroneous pathway against the activation heat map can show locations where the erroneous pathway differs from the statistical distribution of pathways in the activation heat map. To improve DNN accuracy, we can generate additional training data specifically to correct the area where there is a difference in the pathways (e.g. against the heat map). The additional training data can be synthesized using a generative adversarial network (GAN) training methodology.

Hence, the above-described profiling process and the generation of the activation heat map essentially produces an explanation of how the DNN produces an inference result. The process in comparing the erroneous pathways essentially produces an explanation of how the DNN is not robust to that input data set. The process in producing additional data, through data collection or synthesis using GAN, is essentially an adversarial training approach to make the DNN more robust based on profiling process.

In one embodiment, the runtime engine is generated with a compiler to collect data to generate the activation heat map. The runtime engine produces an explanation of the DNN operation. The explanation can be used by a user or deployment packager to initiate adversarial training and generate a more robust DNN. The deployment packager can dispatch the more robust DNN for operation in the field.

Quantization and Processing Based on Tensor Splitting

Many important neural-network models, trained on complex datasets, are not easy to quantize post-training. This is because certain tensors require both range and local resolution that are difficult to achieve using post-training quantization at an 8-bit precision level or below. For example, it is hard to quantize the Depthwise Conv2D layers that are present in MobileNets neural networks because in these layers the weights often vary across a wide range, resulting in loss of information during quantization.

To reduce this information loss, we perform quantization based on a tensor-splitting technique, so that a tensor for a Depthwise Conv2D layer with a large range of values will be split into two sub-tensors. A first sub-tensor clips the range of the weights to a small set of values around the peak distribution, and zeroes out the rest of the “outlier” values. The peak distribution is where most of the tensor values are centered upon. In many cases, the peak distribution is centered around the zero value. The second sub-tensor maintains the outlier values and zeroes out the center values. The goal of this technique is to have the first sub-tensor capture all the important details of the majority of the weights, which are small and centered around the peak distribution, while enabling the second sub-tensor to accurately capture the effect of the outliers.

The splitting threshold associated with this tensor-splitting technique can be determined in a number of ways. In one example, values in a tensor can be split based on how close they are to the mean value of the peak distribution. This can involve splitting based on standard deviation or splitting based on percentile. For example, while splitting based on standard deviation (σ), the threshold values can be (mean−2σ, mean+2σ).

A similar algorithmic tensor-splitting technique involves: (1) splitting the range of the tensor weights into 256 bins; (2) choosing the bin with the mean value as the starting point; (3) moving outward from this starting point left and right, and checking the number of weights in each bin; and (4) using the midpoint of the first encountered empty bin as a threshold value for the splitting.

As mentioned previously, the tensor can alternatively be split into more than two sub-tensors based on multiple peaks in the distribution, wherein each of the more than two sub-tensors is separately quantized using different quantization parameters. Also, to improve performance while subsequently executing the DNN, the first sub-tensor and the second sub-tensor can be selectively computed to dynamically adjust the number of computational operations involved in executing the DNN. The information related to the sub-tensor can be included in runtime metadata to identify portions of the DNN to be selectively executed at runtime. The operational performance of the DNN based on the selected sub-tensors can be reported in the operational performance parameters for use in optimizing the subsequent training of the DNN. Generated operational plan may include the selection of sub-tensors for processing at different intervals. Selected sub-tensors may contain information regarding a watermark pattern encoded during the training process in specific sub-tensors.

Training a Controller to Manage Dynamic Execution of a TNN

As mentioned above, it is often advantageous to dynamically throttle (gate or turn off) portions of a neural network during runtime execution of the neural network in resource-constrained computing devices, which only provide limited amounts of processing power, memory capacity and battery life. In order to facilitate this type of dynamic execution, we have trained both a throttleable neural network (TNN) and an associated context-aware controller that dynamically manages execution of the TNN. A throttleable neural network (TNN) is a neural network that has operational runtime states to achieve better algorithmic performance, for example, via selective activation of modules or sub-tensors in the TNN. A context-aware controller is a runtime engine that operates to select the different operational states of the TNN, wherein the runtime engine can be generated by a compiler based on metadata associated with the TNN. The context-aware controller may be coupled with hardware mechanisms, such as cache, prefetching and other processing elements.

This context-aware controller can be trained using reinforcement learning techniques to selectively activate throttleable modules in the TNN to facilitate execution of specific activation paths. During the training process, our system receives a training data set comprising training examples, wherein each training example comprises an input to the TNN, an output from the TNN and corresponding activation paths through the TNN, which were generated in response to the input. Next, the system uses the reinforcement learning technique to train the controller based on the training data set and a reward function to selectively activate throttleable modules in the TNN to facilitate execution of the activation paths. After training, the controller can be compiled and incorporated into a runtime engine for the TNN. Note that the reward function can balance a number of different objectives, including: maximizing classification accuracy of the TNN; minimizing computational operations performed while executing the TNN; minimizing power consumption of a device, which is executing the TNN; and minimizing latency involved in executing the TNN to produce an output.

In some embodiments, the context-aware controller is trained based on solving a contextual bandit problem. However, many other types of reinforcement learning technique can be used.

In some embodiments, the context-aware controller is composed of policies generated based on a planning agent as described elsewhere in his document. In another embodiment, the context-aware controller may take as inputs, system-level inputs such as battery-levels, available network bandwidth, and memory utilization, to select policies for the TNN. In yet another embodiment, the context-aware controller may select a first and second sub-tensor, as described elsewhere in this document, for executing the TNN to produce an output.

Dynamic Adaptation Framework

FIG. 1A illustrates a dynamic adaptation framework 100 that facilitates executing deep neural networks on resource-constrained computing devices in accordance with the disclosed embodiments.

At the top of FIG. 1A, an AI training system 110 comprises a framework for machine learning, and also incorporates math libraries for DNN training. Referring to FIG. 2, AI training system 110 includes a number of components, including a network architecture search module 111, a quantization module 112, a pruning module 113, a compression module 114, a watermark encoding module 115 and a gated DNN module 116. Network architecture search (NAS) module 111 automates the design of DNN, including selection of hyperparameters (e.g., filter width, DNN depth). NAS module 111 implements strategies to reduce search space and to provide performance estimates. It can also use hardware profile 124 to select a DNN architecture that reduces resource utilization while maintaining performance. Quantization module 112 quantizes the values for DNN parameters to reduce the memory footprint. Pruning module 113 reduces the number of nodes and connections in the DNN to reduce DNN size. In doing so, it can use information from hardware profile 124 to set the threshold on which DNN elements are pruned. Typically, this threshold is set based on the sparsity of values (i.e., lots of zero values may indicate that the DNN element may not typically activate). By using hardware profile 124, the threshold can be set based on computational and memory resources, in addition to the sparsity. Compression module 114 compresses the DNN into a serialized bit stream. It can set the number of symbols used to represent weights by performing weight-value selection, thereby reducing the number of symbols (e.g., values) during training. Watermark encoding module 115 enforces an encoding of watermark pattern 106 into DNN parameters during training. This involves selecting target values for specific DNN parameters based on the watermark pattern 106. Gated DNN module 116 trains the DNN such that the DNN is robust to runtime dropout. Gated DNN module can generate trained DNN dynamic parameters 119 using a planning agent algorithm. Gated DNN module 116 can be coupled with NAS module 111 to identify specific DNN layers for throttling. This module can also take inputs from hardware profile 124 to determine the level of throttling. For example, less hardware resource availability as indicated in hardware profile 124 would suggest a higher level of throttling.

During operation, AI training system 110 receives a number of inputs, including a DNN model 101, which describes a DNN architecture, including descriptions of each layer, neuron type, and connectivity. It also receives training data 102, comprising a prepared data set, which is used to train the neural network. It also receives pre-trained DNN parameters 105, which have been previously generated during AI training. Note that the values of these parameters may be quantized for low bit precision, and can optionally serve as initialization values for AI training system 110. AI training system 110 can also receive a watermark pattern 106, which can be encoded into the DNN during AI training.

The output of AI training system 110 feeds into a visualization module 103, which generates a display output 104 that facilitates visualizing the output of the DNN based on varying bit precision (i.e., intra or inter DNN layer). Exemplary display output 104 presents a histogram of parameter values of a DNN layer, across different bit-precision settings. Note that a poor distribution of parameter values (e.g., with many gaps) often leads to difficulty in classifying objects that have visually similar features (e.g., cat and dog may have similar visual features). A magnified version of display output 104 is illustrated in FIG. 13.

Visualization module 103 can also generate outputs that illustrate the effects of quantization. For example, FIG. 14 illustrates an exemplary compression report, which includes entries for all of the tensors in a DNN. More specifically, this report presents a histogram of weight values for each tensor in the DNN. The left-hand tensor is pre-quantization and the right-hand tenser is post-quantization. The “weight range values” provide ranges of weights for each tensor that is quantized. The “quantization-error values” provide the average difference between pre-quantization and post-quantization weight values. FIG. 15 presents a more detailed report for a single tensor, wherein the left-hand histogram in the report is pre-quantization and the right-hand histogram is post-quantization. The right-hand side of the more detailed report presents specific parameters for the tensor.

AI training system 110 generates a number of items that feed into compiler 120, including: a trained DNN model 117, trained DNN parameters 118, and trained DNN dynamic parameters 119. Trained DNN model 117 comprises a trained DNN model and associated DNN architecture. It is based on DNN model 101, which can be augmented by NAS module 111. It may also include graph information related to low-bit precision, generated by quantization module 112. Trained DNN parameters 118 include the weight values for the DNN parameters. Note that these values may be generated to facilitate low-bit precision operation by quantization module 112.

Trained DNN dynamic parameters 119 include dynamic operational information for compiler 120, including mask information generated by gated DNN module 116 which can be used to throttle the DNN during inferencing operations. The compiler 120 generates code operational as a controller in the throttling module 134 based on the trained DNN dynamic parameters. It can also include information generated by watermark encoding module 115 and compression module 114. During operation, gated DNN module 116 can ingest pre-trained DNN parameters 105 to generate trained DNN dynamic parameters 119. We illustrate the input/output to the AI training system 110 with dotted lines to indicate an alternative workflow, which starts with pre-trained DNN parameters 105.

Compiler 120 also receives application software code 126 and inputs from DNN library 125. Application software code 126 comprises program source code, which for example, can be produced by an application developer. DNN library 125 stores results generated by compiler 120, including application binary 129 and runtime engine 130.

DNN library 125 enables compiler 120 to use previously compiled results to generate a new application binary 129 and runtime engine 130. Compiler 120 can also use previously compiled results from DNN library 125 to generate hardware profile 124 to facilitate subsequent AI training.

Compiler 120 translates program code and other codified sources (e.g., DNN graph descriptions) into executable binaries for processing on hardware 150. During operation, compiler 120 receives as inputs: trained DNN model 117; trained DNN parameters 118; trained DNN dynamic parameters 119; application software code 126; and inputs from DNN library 125. Using these inputs, compiler 120 generates application binary 129 and runtime engine 130, which are operable on device operating system 140 and hardware 150.

Note that compiler 120 can ingest a hardware model 123 for use in generating application binary 129 and runtime engine 130. It can also use hardware model 123 to generate a hardware profile 124 for use by AI training system 110. Hardware model 123 contains information about the hardware 150 (e.g., compute and memory resource available, instruction set architecture). Hardware profile 124 is generated by compiler 120 to facilitate operation of AI training system 110. Hardware profile 124 contains information about how the hardware resources are used based on application binary 129, trained DNN model 117, trained DNN parameters 118 and trained DNN dynamic parameters 119.

Compiler 120 is responsible for resource mapping program code (generated by a developer) or DNN inference graphs in trained DNN model 117 into application binary 129. Referring to FIG. 2, compiler 120 can include a graph optimizer module 121 and tensor optimizer module 122. Graph optimizer module 121 analyzes control flow graphs and data dependencies in order to parallelize computation. In doing so, graph optimizer 121 determines hardware resources (e.g., compute elements and register storage) that are needed to best process the DNN. It also generates portions of the binary code to perform the DNN inference calculations (e.g., multiplication, bit-shifting, comparisons). Tensor optimizer module 122 analyzes the tensor structure (e.g., size, shape, location) to facilitate data loads and stores. In doing so, tensor optimizer 122 generates the data movements necessary to create data streams for the hardware compute elements. Hence, it generates portions of the binary code related to memory transfers and packing of the associated data into streams (e.g., load and store instructions coupled with stride and skip patterns in memory).

Compiler 120 can use trained DNN dynamic parameters 119 to determine operational conditions and constraints, to generate the executable binaries. Hence, trained DNN dynamic parameters 119 can be considered to be compiler directives (e.g., pragmas) that provide additional information to select various compiler optimizations (e.g., vectorization and loop unrolling). Compiler 120 also generates information in the hardware profile 124, including information related to hardware resource utilization, memory bandwidth availability, and power consumption, based on output of the graph optimizer 121 and tensor optimizer 122. The compiler 120 generates code for the application binary 129, runtime engine 130, and the deployment packager 127.

Deployment packager 127 provides storage for application binary 129 and runtime engine 130. Deployment packager 127 can store different code versions for later deployment (e.g., over-the-air releases), shown with the dotted line to application binary 129 and runtime engine 130. Deployment packager 127 may initiate adversarial training (e.g. using AI training 110) and compilation (e.g. using compiler 120) based on results from runtime engine 130, in which the adversarial trained DNN is stored for later deployment.

Runtime engine 130 comprises executable binaries generated by compiler 120 to perform common functions to facilitate DNN inferencing operations, including functions for data processing generated by the graph optimizer 121, and instructions for stream data movement, generated by the tensor optimizer 122. As illustrated in FIG. 2, runtime engine 130 includes: watermark decoding module 131, decompression module 132, DNN data prefetch module 133, throttling module 134 and active visualization module 135. Watermark decoding module 131 comprises code that decodes a watermark pattern in the trained DNN parameters 118, which was previously encoded by watermark encoding module 115. Decompression module 132 comprises code that decompresses the trained DNN parameters 118 based on a scheme defined in compression module 114. DNN data prefetch module 133 comprises code to load, store, and pack data into streams for processing. Throttling module 134 comprises code that constitutes a controller, which uses sensor data to dynamically determine operational conditions of the DNN inference. The controller may collect profile data to generate activation heat maps to provide explanations of DNN inference. In addition, code within throttling module 134 performs approximations for functions in the DNN inference. Active visualization module 135 includes code that provides an output of the DNN inference, which shows the activation paths that lead to the DNN output (e.g., classification results). These activation paths can be related to the throttling (e.g., selected paths that are turned on for processing). If the confidence results of the DNN output are low, and the activation paths indicate there are additional pathways for DNN activations, then throttling module 134 can increase the compute-level to improve DNN output results. Display output module 136 includes code that generates a visual display of activation paths of the DNN during inference. Note that these DNN activation paths can help to explain DNN behavior (e.g., why did DNN choose particular output instead of another to facilitate throttling operations performed by throttling module 134).

Flow Charts

FIG. 3A presents a flow chart illustrating operations performed while facilitating dynamic runtime execution of a DNN in accordance with the disclosed embodiments. During operation, the system receives a model, a set of weights and runtime metadata for the DNN (step 302). Next, the system obtains code to perform inference-processing operations for the DNN (step 304). Finally, the system compiles code to implement a runtime engine that facilitates throttling operations during execution of the inference-processing operations, wherein during the throttling operations, the runtime engine identifies portions of the DNN to mask out and/or selects portions of the DNN to traverse based on a graph analysis involving the model, the set of weights and the runtime metadata (step 306).

FIG. 3B presents a flow chart illustrating operations performed while optimizing execution of a DNN based on operational performance parameters in accordance with the disclosed embodiments. During operation, the system collects operational performance parameters from the DNN during operation of the DNN, wherein the operational performance parameters include parameters associated with operating conditions for the DNN, parameters associated with resource utilization during operation of the DNN, and parameters associated with accuracy of results produced by the DNN (step 312). Next, the system uses the operational performance parameters to update the DNN model to improve performance and efficiency during execution of the DNN (step 314).

FIG. 4 presents a flow chart illustrating operations performed while generating runtime metadata for a DNN in accordance with the disclosed embodiments. During operation, the system performs post-training operations on the DNN to identify effective execution paths through the DNN to produce desired computational results. While performing the post-training operations, the system first evaluates an inference of the DNN across a test data set and stores associated DNN activations (step 402). Next, the system selects statistically relevant execution paths through the DNN based on the DNN activations (step 404). Finally, the system generates the runtime metadata based on the selected execution paths through the DNN, wherein the DNN metadata identifies portions of the DNN to be selectively executed at runtime (step 406).

FIG. 5 presents a flow chart illustrating operations performed while generating DNN runtime metadata to facilitate training a DNN in accordance with the disclosed embodiments. During operation, the system receives a DNN model and associated parameters at a DNN training interval (step 502). Next, the system generates compiler intermediate representations based on the DNN model and associated parameters and available computing resources (step 504). The system then generates the DNN metadata based on the compiler intermediate representations, wherein the DNN metadata comprises information, including one or more of computing resource utilization, memory bandwidth availability, and power consumption (step 506). Finally, the system uses the DNN metadata during a subsequent training operation for the DNN (step 508).

FIG. 6 presents a flow chart illustrating operations performed while executing a DNN based on a current operational context in accordance with the disclosed embodiments. During operation, the system receives a current runtime state for the DNN, comprising a current neural network (NN) execution context and a current DNN input context, wherein the current DNN execution context comprises current DNN activations and/or DNN outputs, and wherein the current DNN input context comprises contextual features associated with current inputs to the DNN (step 602). Next, the system uses the current runtime state to determine a target runtime state for the DNN (step 604). The system then generates an operational plan to achieve the target runtime state from the current runtime state (step 606). Finally, the system controls the DNN to execute the operational plan (step 608).

FIG. 7 presents a flow chart illustrating operations performed while watermarking a DNN in accordance with the disclosed embodiments. During operation, the system receives a watermark pattern (step 702). Next, during a training operation for the DNN, the system constrains DNN parameters based on values in the watermark pattern, so that after the training completes, the watermark pattern is encoded in the DNN parameters of the trained DNN (step 704).

FIG. 8 presents a flow chart illustrating operations performed while compressing a DNN in accordance with the disclosed embodiments. During operation, the system receives a trained DNN, which includes DNN parameter values (step 802). Next, the system generates a dictionary for the DNN parameter values (step 804). Finally, the system encodes the DNN parameter values using corresponding dictionary index values (step 806).

FIG. 9 presents a flow chart illustrating operations performed while facilitating visualization of DNN training results across different bit precisions in accordance with the disclosed embodiments. During operation, the system trains and tests the accuracy of a DNN using different bit precisions for DNN weights (step 902). Next, the system displays a histogram of the DNN weights and associated accuracy results for each of the different bit precisions to facilitate visualizing how bit precision affects discrimination capabilities of the DNN (step 904).

FIG. 10 presents a flow chart illustrating operations performed while processing neural network inferences in a neural network (DNN) using bit planes in accordance with the disclosed embodiments. During operation, the system separates a tensor associated with the DNN into bit planes (step 1002). The system then resolves the bit planes, wherein matrix multiplication and summation operations in the convolution are resolved using a bit-counting process, and wherein pooling and non-linear activation operations are resolved by using each of the bit planes as a new input vector (step 1004).

FIG. 11 presents a flow chart illustrating operations performed while quantizing a DNN based on tensor splitting to reduce information loss. During operation, the system receives a tensor, which is associated with a layer of the DNN, wherein a distribution of values in the tensor includes a peak (step 1102). Next, the system splits the tensor into sub-tensors, wherein a first sub-tensor includes values in proximity to the peak and a second sub-tensor includes values that are not in proximity to the peak (step 1104). Finally, the system separately quantizes the first and second sub-tensors using different quantization parameters to improve accuracy and reduce information loss (step 1106).

FIG. 12 presents a flow chart illustrating operations performed while training a controller to manage runtime execution of a TNN. During operation, the system receives a training data set comprising training examples, wherein each training example comprises an input to the TNN and corresponding activation paths through the TNN, which were generated in response to the input (step 1202). Next, the system uses a reinforcement learning technique to train the controller based on the training data set and a reward function to selectively activate throttleable modules in the TNN to facilitate execution of the activation paths (step 1204).

Various modifications to the disclosed embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other embodiments and applications without departing from the spirit and scope of the present invention. Thus, the present invention is not limited to the embodiments shown, but is to be accorded the widest scope consistent with the principles and features disclosed herein.

The foregoing descriptions of embodiments have been presented for purposes of illustration and description only. They are not intended to be exhaustive or to limit the present description to the forms disclosed. Accordingly, many modifications and variations will be apparent to practitioners skilled in the art. Additionally, the above disclosure is not intended to limit the present description. The scope of the present description is defined by the appended claims. 

1. A method for facilitating dynamic runtime execution of a deep neural network (DNN), comprising: receiving a model, a set of weights and runtime metadata for the DNN; obtaining code to perform inference-processing operations for the DNN; and compiling code to implement a runtime engine that facilitates throttling operations during execution of the inference-processing operations, wherein the runtime engine conserves computing resources by selecting portions of the inference-processing operations to execute based on the runtime metadata.
 2. The method of claim 1, wherein during the throttling operations, the runtime engine identifies portions of the DNN to mask out and/or selects portions of the DNN to traverse based on a graph analysis involving the model, the set of weights and the runtime metadata.
 3. The method of claim 2, wherein the graph analysis involves scheduling data-fetching operations based on the runtime metadata to facilitate execution of the DNN.
 4. The method of claim 1, wherein the runtime metadata comprises information about statistically relevant execution paths through the DNN, which are determined based on activations in the DNN and associated sub-tensors.
 5. The method of claim 1, wherein the runtime metadata specifies runtime masks to facilitate selectively executing inference-processing operations for the DNN.
 6. The method of claim 5, wherein the runtime metadata specifies different masks for different DNN outputs.
 7. The method of claim 1, wherein the runtime engine is configured to cryptographically decode a watermark pattern encoded in the set of weights to facilitate validating the DNN.
 8. The method of claim 1, wherein the runtime engine is configured to determine a current runtime state and a target runtime state for the DNN, wherein the throttling operations select an operational plan to achieve the target runtime state from the current runtime state.
 9. The method of claim 8, wherein the current runtime state comprises a current execution context and a current input context, wherein the current execution context comprises current activations and/or outputs for the DNN, and the current input context comprises contextual features associated with current inputs to the DNN.
 10. The method of claim 1, wherein the runtime engine is configured to decode the set of weights during the inference-processing operations based on dictionary index values in the runtime metadata.
 11. A non-transitory computer-readable storage medium storing instructions that when executed by a computer cause the computer to perform a method for facilitating dynamic runtime execution of a deep neural network (DNN), the method comprising: receiving a model, a set of weights and runtime metadata for the DNN; obtaining code to perform inference-processing operations for the DNN; and compiling code to implement a runtime engine that facilitates throttling operations during execution of the inference-processing operations, wherein the runtime engine conserves computing resources by selecting portions of the inference-processing operations to execute based on the runtime metadata.
 12. The non-transitory computer-readable storage medium of claim 11, wherein during the throttling operations, the runtime engine identifies portions of the DNN to mask out and/or selects portions of the DNN to traverse based on a graph analysis involving the model, the set of weights and the runtime metadata.
 13. The non-transitory computer-readable storage medium of claim 12, wherein the graph analysis involves scheduling data-fetching operations based on the runtime metadata to facilitate execution of the DNN.
 14. The non-transitory computer-readable storage medium of claim 11, wherein the runtime metadata comprises information about statistically relevant execution paths through the DNN, which are determined based on activations in the DNN and associated sub-tensors.
 15. The non-transitory computer-readable storage medium of claim 11, wherein the runtime metadata specifies runtime masks to facilitate selectively executing inference-processing operations for the DNN.
 16. The non-transitory computer-readable storage medium of claim 15, wherein the runtime metadata specifies different masks for different DNN outputs.
 17. The non-transitory computer-readable storage medium of claim 11, wherein the runtime engine is configured to cryptographically decode a watermark pattern encoded in the set of weights to facilitate validating the DNN.
 18. The non-transitory computer-readable storage medium of claim 11, wherein the runtime engine is configured to determine a current runtime state and a target runtime state for the DNN, wherein the throttling operations select an operational plan to achieve the target runtime state from the current runtime state.
 19. The non-transitory computer-readable storage medium of claim 18, wherein the current runtime state comprises a current execution context and a current input context, wherein the current execution context comprises current activations and/or outputs for the DNN, and the current input context comprises contextual features associated with current inputs to the DNN.
 20. The non-transitory computer-readable storage medium of claim 11, wherein the runtime engine is configured to decode the set of weights during the inference-processing operations based on dictionary index values in the runtime metadata.
 21. A system that facilitates dynamic runtime execution of a deep neural network (DNN), comprising: at least one processor and at least one associated memory; and a processing mechanism that executes on the at least one processor, wherein during operation, the processing mechanism: receives a model, a set of weights and runtime metadata for the DNN; obtains code to perform inference-processing operations for the DNN; and compiles code to implement a runtime engine that facilitates throttling operations during execution of the inference-processing operations, wherein the runtime engine conserves computing resources by selecting portions of the inference-processing operations to execute based on the runtime metadata.
 22. The system of claim 21, wherein during the throttling operations, the runtime engine identifies portions of the DNN to mask out and/or selects portions of the DNN to traverse based on a graph analysis involving the model, the set of weights and the runtime metadata. 